<!doctype html>
<html lang="zh-cn">
  <head>
    <title>深拷贝和浅拷贝 // JW Blog</title>
    <meta charset="utf-8" />
    <meta name="generator" content="Hugo 0.60.1" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="author" content="John Doe" />
    <meta name="description" content="" />
    <link rel="stylesheet" href="https://duyi111.gitee.io/css/main.min.f90f5edd436ec7b74ad05479a05705770306911f721193e7845948fb07fe1335.css" />

    
    <meta name="twitter:card" content="summary"/>
<meta name="twitter:title" content="深拷贝和浅拷贝"/>
<meta name="twitter:description" content="1.浅拷贝  copy函数是浅拷贝，只对可变类型的第一层对象进行拷贝，对拷贝的对象开辟新的内存空间进行存储，不会拷贝对象内部的子对象。  1.1 不可变类型的浅拷贝示例代码 import copy # 使用浅拷贝需要导入copy模块 # 不可变类型有：数字，字符串，元组 a1 = 123123 b1 = copy.copy(a1) # 使用copy模块里的copy()函数就是浅拷贝 # 查看内存地址 print(id(a1)) print(id(b1)) print(&#39;-&#39; * 10) a2 = &#39;abc&#39; b2 = copy.copy(a2) # 查看内存地址 print(id(a2)) print(id(b2)) print(&#39;-&#39; * 10) a3 = (1, 3, [&#39;hello&#39;, &#39;world&#39;]) b3 = copy.copy(a3) # 查看内存地址 print(id(a3)) print(id(b3))  运行结果：  140459558944048 140459558944048 ---------- 140459558648776 140459558648776 ---------- 140459558073328 140459558073328  不可变类型的浅拷贝说明：  通过上面的执行结果可以得知，不可变类型进行浅拷贝不会给拷贝的对象开辟新的内存空间，而只是拷贝了这个对象的引用。    1."/>

    <meta property="og:title" content="深拷贝和浅拷贝" />
<meta property="og:description" content="1.浅拷贝  copy函数是浅拷贝，只对可变类型的第一层对象进行拷贝，对拷贝的对象开辟新的内存空间进行存储，不会拷贝对象内部的子对象。  1.1 不可变类型的浅拷贝示例代码 import copy # 使用浅拷贝需要导入copy模块 # 不可变类型有：数字，字符串，元组 a1 = 123123 b1 = copy.copy(a1) # 使用copy模块里的copy()函数就是浅拷贝 # 查看内存地址 print(id(a1)) print(id(b1)) print(&#39;-&#39; * 10) a2 = &#39;abc&#39; b2 = copy.copy(a2) # 查看内存地址 print(id(a2)) print(id(b2)) print(&#39;-&#39; * 10) a3 = (1, 3, [&#39;hello&#39;, &#39;world&#39;]) b3 = copy.copy(a3) # 查看内存地址 print(id(a3)) print(id(b3))  运行结果：  140459558944048 140459558944048 ---------- 140459558648776 140459558648776 ---------- 140459558073328 140459558073328  不可变类型的浅拷贝说明：  通过上面的执行结果可以得知，不可变类型进行浅拷贝不会给拷贝的对象开辟新的内存空间，而只是拷贝了这个对象的引用。    1." />
<meta property="og:type" content="article" />
<meta property="og:url" content="https://duyi111.gitee.io/post/%E6%B7%B1%E6%8B%B7%E8%B4%9D%E5%92%8C%E6%B5%85%E6%8B%B7%E8%B4%9D/" />
<meta property="article:published_time" content="2020-02-10T21:16:31+08:00" />
<meta property="article:modified_time" content="2020-02-10T21:16:31+08:00" />


  </head>
  <body>
    <header class="app-header">
      <a href="https://duyi111.gitee.io/"><img class="app-header-avatar" src="/avatar.jpg" alt="John Doe" /></a>
      <h1>JW Blog</h1>
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc vehicula turpis sit amet elit pretium.</p>
      <div class="app-header-social">
        
      </div>
    </header>
    <main class="app-container">
      
  <article class="post">
    <header class="post-header">
      <h1 class ="post-title">深拷贝和浅拷贝</h1>
      <div class="post-meta">
        <div>
          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="icon icon-calendar">
  <title>calendar</title>
  <rect x="3" y="4" width="18" height="18" rx="2" ry="2"></rect><line x1="16" y1="2" x2="16" y2="6"></line><line x1="8" y1="2" x2="8" y2="6"></line><line x1="3" y1="10" x2="21" y2="10"></line>
</svg>
          Feb 10, 2020
        </div>
        <div>
          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="icon icon-clock">
  <title>clock</title>
  <circle cx="12" cy="12" r="10"></circle><polyline points="12 6 12 12 16 14"></polyline>
</svg>
          2 min read
        </div></div>
    </header>
    <div class="post-content">
      <h2 id="1">1.浅拷贝</h2>
<ul>
<li>copy函数是浅拷贝，只对可变类型的第一层对象进行拷贝，对拷贝的对象开辟新的内存空间进行存储，不会拷贝对象内部的子对象。</li>
</ul>
<h4 id="11-">1.1 不可变类型的浅拷贝示例代码</h4>
<pre><code>import copy # 使用浅拷贝需要导入copy模块

# 不可变类型有：数字，字符串，元组

a1 = 123123
b1 = copy.copy(a1)  # 使用copy模块里的copy()函数就是浅拷贝
# 查看内存地址
print(id(a1))
print(id(b1))

print('-' * 10)
a2 = 'abc'
b2 = copy.copy(a2)
# 查看内存地址
print(id(a2))
print(id(b2))

print('-' * 10)
a3 = (1, 3, ['hello', 'world'])
b3 = copy.copy(a3)
# 查看内存地址
print(id(a3))
print(id(b3))

</code></pre><ul>
<li>运行结果：</li>
</ul>
<pre><code>140459558944048
140459558944048
----------
140459558648776
140459558648776
----------
140459558073328
140459558073328
</code></pre><ul>
<li>不可变类型的浅拷贝说明：
<ul>
<li>通过上面的执行结果可以得知，不可变类型进行浅拷贝不会给拷贝的对象开辟新的内存空间，而只是拷贝了这个对象的引用。</li>
</ul>
</li>
</ul>
<h4 id="12-">1.2 可变类型的浅拷贝示例代码</h4>
<pre><code>import copy  # 使用浅拷需要导入copy模块

# 可变类型有：列表、字典、集合

a1 = [1, 2]
b1 = copy.copy(a1)  # 使用copy模块里的copy()函数就是浅拷贝
# 查看内存地址
print(id(a1))
print(id(b1))

print('-' * 10)
a2 = {'name': '小白', 'age': '18'}
b2 = copy.copy(a2)
# 查看内存地址
print(id(a2))
print(id(b2))

print('-' * 10)
a3 = {1, 2, '小白'}
b3 = copy.copy(a3)
# 查看内存地址
print(id(a3))
print(id(b3))

print('-' * 10)
a4 = [1, 2, [4, 5]]
# 注意：浅拷贝只会拷贝父对象，不会对子对象进行拷贝
b4 = copy.copy(a4)
# 查看内存地址
print(id(a4))
print(id(b4))
print(id(a4[2]))
print(id(b4[2]))

# 修改数据
a4[2][0] = 6
# 子对象的数据会受影响
print(a4)
print(b4)
</code></pre><ul>
<li>运行结果：</li>
</ul>
<pre><code>139882899585608
139882899585800
----------
139882919626432
139882919626504
----------
139882919321672
139882899616264
----------
139882899587016
139882899586952
139882899693640
139882899693640
[1, 2, [6, 5]]
[1, 2, [6, 5]]
</code></pre><ul>
<li>可变类型的浅拷贝说明：
<ul>
<li>通过上面的执行结果可以得知，可变类型进行浅拷贝只对可变类型的第一层对象进行拷贝，对拷贝的对象会开辟新的内存空间进行存储，子对象不进行拷贝。</li>
</ul>
</li>
</ul>
<h2 id="2">2.深拷贝</h2>
<ul>
<li>deepcopy函数是深拷贝，只要发现对象有可变类型就会对该对象到最后一个可变类型的每一层对象进行拷贝，对每一层拷贝的对象都会开辟新的内存空间进行存储。</li>
</ul>
<h4 id="21-">2.1 不可变类型的深拷贝示例代码</h4>
<pre><code>import copy  # 使用深拷贝需要导入copy模块

# 不可变类型有：数字、字符串、元组

a1 = 123
b1 = copy.deepcopy(a1)  # 使用copy模块中的deepcopy()函数就是深拷贝
# 查看内存地址
print(id(a1))
print(id(b1))

print('-' * 10)
a2 = '小白'
b2 = copy.deepcopy(a2)
# 查看内存地址
print(id(a2))
print(id(b2))

print('-' * 10)
a3 = (1, 2)
b3 = copy.deepcopy(a3)
#查看内存地址
print(id(a3))
print(id(b3))

print('-' * 10)
# 注意：元组里面要是有可变类型对象，发现对象有可变类型就会该对象到最后一个可变类型的每一层对象进行拷贝
a4 = (1, ['小白'])
b4 = copy.deepcopy(a4)
# 查看内存地址
print(id(a4))
print(id(b4))
# 元组里面的可变类型子对象也会进行拷贝
print(id(a4[1]))
print(id(b4[1]))

</code></pre><ul>
<li>运行结果：</li>
</ul>
<pre><code>9289120
9289120
----------
140115621848320
140115621848320
----------
140115621859592
140115621859592
----------
140115602480584
140115621834568
140115602328136
140115602436168
</code></pre><ul>
<li>不可变类型的深拷贝说明：
<ul>
<li>通过上面的执行结果可以得知：
<ul>
<li>不可变类型进行深拷贝如果子对象没有可变类型则不会进行拷贝，而只是拷贝了这个对象的引用，否则会对该对象到最后一个可变类型的每一层对象进行拷贝，对每一层拷贝的对象都会开辟新的内存空间进行存储。</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4 id="22-">2.2 可变类型的深拷贝示例代码</h4>
<pre><code>import copy  # 使用深拷贝需要导入copy模块

# 可变类型有: 列表、字典、集合

a1 = [1, 2]
b1 = copy.deepcopy(a1)  # 使用copy模块里的deepcopy()函数就是深拷贝了
# 查看内存地址
print(id(a1))
print(id(b1))
print(&quot;-&quot; * 10)
a2 = {&quot;name&quot;: &quot;张三&quot;}
b2 = copy.deepcopy(a2)
# 查看内存地址
print(id(a2))
print(id(b2))
print(&quot;-&quot; * 10)
a3 = {1, 2}
b3 = copy.deepcopy(a3)
# 查看内存地址
print(id(a3))
print(id(b3))
print(&quot;-&quot; * 10)

a4 = [1, 2, [&quot;李四&quot;, &quot;王五&quot;]]
b4 = copy.deepcopy(a4)  # 使用copy模块里的deepcopy()函数就是深拷贝了
# 查看内存地址
print(id(a4))
print(id(b4))

# 查看内存地址
print(id(a4[2]))
print(id(b4[2]))
a4[2][0] = &quot;王五&quot;
# 因为列表的内存地址不同，所以数据不会收到影响
print(a4)
print(b4)
</code></pre><ul>
<li>运行结果：</li>
</ul>
<pre><code>140348291721736
140348291721928
----------
140348311762624
140348311221592
----------
140348311457864
140348291752456
----------
140348291723080
140348291723144
140348291723208
140348291723016
[1, 2, ['王五', '王五']]
[1, 2, ['李四', '王五']]
</code></pre><ul>
<li>可变类型的深拷贝说明：
<ul>
<li>通过上面的执行结果可以得知，可变类型进行深拷贝会对该对象到最后一个可变类型的每一层对象进行拷贝，对每一层拷贝的对象都会开辟新的内存空间进行存储。</li>
</ul>
</li>
</ul>
<h2 id="3">3.浅拷贝和深拷贝的区别</h2>
<ul>
<li>浅拷贝最多拷贝对象的一层</li>
<li>深拷贝能拷贝对象的多层</li>
</ul>
<h2 id="4">4.总结</h2>
<ul>
<li>浅拷贝使用<code>copy.copy</code>函数</li>
<li>深拷贝使用<code>copy.deepcopy</code>函数</li>
<li>不管是给对象进行深拷贝还是浅拷贝，只要拷贝成功就会开辟新的内存空间存储拷贝的对象。</li>
<li>浅拷贝和深拷贝的区别是：
<ul>
<li>浅拷贝最多拷贝对象的一层，深拷贝能拷贝对象的多层。</li>
</ul>
</li>
</ul>

    </div>
    <div class="post-footer">
      
    </div>
  </article>

    </main>
  </body>
</html>
